santree 0.3.0 → 0.4.0

package/README.md

@@ -317,6 +317,15 @@ echo "$(date): $SANTREE_TICKET_ID waiting — $SANTREE_MESSAGE" >> /tmp/santree-
 
 Make it executable: `chmod +x .santree/hooks/on-waiting.sh`
 
+### Environment Variables
+
+| Variable | Effect |
+|---|---|
+| `SANTREE_EDITOR` | Editor used by `e` (open in editor) actions in the dashboard. Defaults to `code`. Examples: `cursor`, `zed`, `code`, `nvim`. |
+| `SANTREE_MULTIPLEXER` | Terminal multiplexer used by the dashboard and `worktree create --window`. One of `tmux`, `cmux`, `none`. If unset, auto-detects from `$TMUX` / `$CMUX_SURFACE_ID`. cmux is macOS-only and limited by [manaflow-ai/cmux#1472](https://github.com/manaflow-ai/cmux/issues/1472). |
+
+Santree always launches Claude with `--permission-mode auto` (Claude Code's auto mode), or `plan` when invoked in plan mode. Worktree-scoped automation is the default — there is no opt-in flag.
+
 ---
 
 ## Command Options

package/dist/commands/dashboard.js

@@ -13,6 +13,7 @@ import { findMainRepoRoot, createWorktree, getDefaultBranch, getBaseBranch, hasI
 import { run, spawnAsync } from "../lib/exec.js";
 import { resolveAgentBinary } from "../lib/ai.js";
 import { extractTicketId } from "../lib/git.js";
+import { getMultiplexer } from "../lib/multiplexer/index.js";
 import { getPRTemplate } from "../lib/github.js";
 import { renderPrompt, renderDiff, renderTicket } from "../lib/prompts.js";
 import { getTicketContent } from "../lib/linear.js";
@@ -39,9 +40,6 @@ const CLAUDE_VERSION = (() => {
     }
 })();
 // ── Helpers ───────────────────────────────────────────────────────────
-function isInTmux() {
-    return !!process.env.TMUX;
-}
 function slugify(title) {
     return title
         .toLowerCase()
@@ -137,12 +135,7 @@ function ensureAltScreen() {
     if (altScreenEntered)
         return;
     altScreenEntered = true;
-    if (isInTmux()) {
-        try {
-            execSync('tmux rename-window "santree"', { stdio: "ignore" });
-        }
-        catch { }
-    }
+    getMultiplexer().renameWindow("", "santree");
     process.stdout.write("\x1b[?1049h"); // Enter alternate screen buffer
     process.stdout.write("\x1b[?25l"); // Hide cursor
 }
@@ -385,66 +378,81 @@ export default function Dashboard() {
         };
     }, [state.overlay, state.contextInputPhase, state.prCreatePhase]);
     // ── Actions ───────────────────────────────────────────────────────
-    const launchWorkInTmux = useCallback((di, mode, worktreePath, contextFile) => {
+    const launchWorkInTmux = useCallback(async (di, mode, worktreePath, contextFile) => {
         const windowName = di.issue.identifier;
         const sessionId = di.worktree?.sessionId;
         const bin = resolveAgentBinary();
         const resumeCmd = sessionId && bin ? `${bin} --resume ${sessionId}` : null;
         const contextArg = contextFile ? ` --context-file "${contextFile}"` : "";
         const workCmd = mode === "plan" ? `st worktree work --plan${contextArg}` : `st worktree work${contextArg}`;
-        try {
-            // Switch to existing window if it exists
-            execSync(`tmux select-window -t "${windowName}"`, { stdio: "ignore" });
-            const cmd = resumeCmd ?? workCmd;
-            execSync(`tmux send-keys -t "${windowName}" "${cmd}" Enter`, { stdio: "ignore" });
-            dispatch({
-                type: "SET_ACTION_MESSAGE",
-                message: resumeCmd
-                    ? `Resumed session in: ${windowName}`
-                    : `Launched ${mode} in: ${windowName}`,
-            });
+        const cmd = resumeCmd ?? workCmd;
+        const mux = getMultiplexer();
+        const selected = await mux.selectWindow(windowName);
+        if (selected.ok) {
+            const sent = mux.sendCommand(windowName, cmd);
+            if (sent.ok) {
+                dispatch({
+                    type: "SET_ACTION_MESSAGE",
+                    message: resumeCmd
+                        ? `Resumed session in: ${windowName}`
+                        : `Launched ${mode} in: ${windowName}`,
+                });
+            }
+            else {
+                dispatch({
+                    type: "SET_ACTION_MESSAGE",
+                    message: `Focused ${windowName} — run \`${cmd}\` manually (${sent.reason})`,
+                });
+            }
         }
-        catch {
-            // Window doesn't exist — create it
-            try {
-                execSync(`tmux new-window -n "${windowName}" -c "${worktreePath}"`, { stdio: "ignore" });
-                // Small delay so the new shell can start reading input before we send keys,
-                // otherwise buffered keystrokes from the dashboard pane can leak in.
-                execSync("sleep 0.1", { stdio: "ignore" });
-                const cmd = resumeCmd ?? workCmd;
-                execSync(`tmux send-keys -t "${windowName}" "${cmd}" Enter`, { stdio: "ignore" });
+        else {
+            const created = await mux.createWindow({
+                name: windowName,
+                cwd: worktreePath,
+                command: cmd,
+            });
+            if (created.ok) {
                 dispatch({
                     type: "SET_ACTION_MESSAGE",
                     message: resumeCmd
                         ? `Resumed session in new window: ${windowName}`
-                        : `Launched ${mode} in tmux window: ${windowName}`,
+                        : `Launched ${mode} in ${mux.kind} window: ${windowName}`,
                 });
             }
-            catch {
-                dispatch({ type: "SET_ACTION_MESSAGE", message: "Failed to create tmux window" });
+            else {
+                dispatch({
+                    type: "SET_ACTION_MESSAGE",
+                    message: `Failed to create ${mux.kind} window${created.message ? `: ${created.message}` : ""}`,
+                });
             }
         }
         // Delayed refresh to pick up session ID created by `st worktree work`
         setTimeout(() => refresh(), 3000);
     }, [refresh]);
-    const launchAfterCreation = useCallback((mode, worktreePath, ticketId, contextFile) => {
-        if (isInTmux()) {
+    const launchAfterCreation = useCallback(async (mode, worktreePath, ticketId, contextFile) => {
+        const mux = getMultiplexer();
+        if (mux.isActive()) {
             const windowName = ticketId;
             const contextArg = contextFile ? ` --context-file "${contextFile}"` : "";
             const workCmd = mode === "plan"
                 ? `st worktree work --plan${contextArg}`
                 : `st worktree work${contextArg}`;
-            try {
-                execSync(`tmux new-window -n "${windowName}" -c "${worktreePath}"`, { stdio: "ignore" });
-                execSync("sleep 0.1", { stdio: "ignore" });
-                execSync(`tmux send-keys -t "${windowName}" "${workCmd}" Enter`, { stdio: "ignore" });
+            const created = await mux.createWindow({
+                name: windowName,
+                cwd: worktreePath,
+                command: workCmd,
+            });
+            if (created.ok) {
                 dispatch({
                     type: "SET_ACTION_MESSAGE",
                     message: `Created worktree + launched ${mode} in: ${windowName}`,
                 });
             }
-            catch {
-                dispatch({ type: "SET_ACTION_MESSAGE", message: "Worktree created, but tmux failed" });
+            else {
+                dispatch({
+                    type: "SET_ACTION_MESSAGE",
+                    message: `Worktree created, but ${mux.kind} failed${created.message ? `: ${created.message}` : ""}`,
+                });
             }
             setTimeout(() => refresh(), 3000);
         }
@@ -590,8 +598,8 @@ export default function Dashboard() {
         const contextFile = writeContextFile(customContext);
         if (di.worktree) {
             // Worktree exists — launch work
-            if (isInTmux()) {
-                launchWorkInTmux(di, mode, di.worktree.path, contextFile);
+            if (getMultiplexer().isActive()) {
+                void launchWorkInTmux(di, mode, di.worktree.path, contextFile);
             }
             else {
                 leaveAltScreen();
@@ -1225,7 +1233,7 @@ export default function Dashboard() {
                 dispatch({ type: "SET_ACTION_MESSAGE", message: `Opened in ${editor}` });
                 return;
             }
-            // AI Review in tmux
+            // AI Review in multiplexer
             if (input === "r") {
                 if (!ri.worktree) {
                     dispatch({
@@ -1234,21 +1242,23 @@ export default function Dashboard() {
                     });
                     return;
                 }
-                if (isInTmux()) {
+                const mux = getMultiplexer();
+                if (mux.isActive()) {
                     const windowName = `review-${extractTicketId(ri.branch ?? "") ?? ri.pr.number}`;
-                    try {
-                        execSync(`tmux new-window -n "${windowName}" -c "${ri.worktree.path}"`, {
-                            stdio: "ignore",
+                    const cwd = ri.worktree.path;
+                    void (async () => {
+                        const created = await mux.createWindow({
+                            name: windowName,
+                            cwd,
+                            command: "st pr review",
                         });
-                        execSync("sleep 0.1", { stdio: "ignore" });
-                        execSync(`tmux send-keys -t "${windowName}" "st pr review" Enter`, {
-                            stdio: "ignore",
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: created.ok
+                                ? `Launched AI review in ${mux.kind}`
+                                : `Failed to launch review${created.message ? `: ${created.message}` : ""}`,
                         });
-                        dispatch({ type: "SET_ACTION_MESSAGE", message: "Launched AI review in tmux" });
-                    }
-                    catch {
-                        dispatch({ type: "SET_ACTION_MESSAGE", message: "Failed to launch review" });
-                    }
+                    })();
                 }
                 else {
                     leaveAltScreen();
@@ -1330,30 +1340,30 @@ export default function Dashboard() {
                 dispatch({ type: "SET_ACTION_MESSAGE", message: "No worktree to switch to" });
                 return;
             }
-            if (isInTmux()) {
+            const mux = getMultiplexer();
+            if (mux.isActive()) {
                 const windowName = di.issue.identifier;
                 const sessionId = di.worktree.sessionId;
                 const bin = resolveAgentBinary();
                 const resumeCmd = sessionId && bin ? `${bin} --resume ${sessionId}` : null;
-                try {
-                    execSync(`tmux select-window -t "${windowName}"`, { stdio: "ignore" });
-                }
-                catch {
-                    // Window doesn't exist — create one and resume/launch
-                    try {
-                        execSync(`tmux new-window -n "${windowName}" -c "${di.worktree.path}"`, {
-                            stdio: "ignore",
-                        });
-                        execSync("sleep 0.1", { stdio: "ignore" });
-                        const cmd = resumeCmd ?? "st worktree work";
-                        execSync(`tmux send-keys -t "${windowName}" "${cmd}" Enter`, {
-                            stdio: "ignore",
+                const worktreePath = di.worktree.path;
+                void (async () => {
+                    const selected = await mux.selectWindow(windowName);
+                    if (selected.ok)
+                        return;
+                    const cmd = resumeCmd ?? "st worktree work";
+                    const created = await mux.createWindow({
+                        name: windowName,
+                        cwd: worktreePath,
+                        command: cmd,
+                    });
+                    if (!created.ok) {
+                        dispatch({
+                            type: "SET_ACTION_MESSAGE",
+                            message: `Failed to switch ${mux.kind} window${created.message ? `: ${created.message}` : ""}`,
                         });
                     }
-                    catch {
-                        dispatch({ type: "SET_ACTION_MESSAGE", message: "Failed to switch tmux window" });
-                    }
-                }
+                })();
             }
             else {
                 leaveAltScreen();
@@ -1408,18 +1418,23 @@ export default function Dashboard() {
                 dispatch({ type: "SET_ACTION_MESSAGE", message: "No PR to review" });
                 return;
             }
-            if (isInTmux()) {
+            const mux = getMultiplexer();
+            if (mux.isActive()) {
                 const windowName = `review-${di.issue.identifier}`;
-                try {
-                    execSync(`tmux new-window -n "${windowName}" -c "${di.worktree.path}"`, {
-                        stdio: "ignore",
+                const cwd = di.worktree.path;
+                void (async () => {
+                    const created = await mux.createWindow({
+                        name: windowName,
+                        cwd,
+                        command: "st pr review",
                     });
-                    execSync(`tmux send-keys -t "${windowName}" "st pr review" Enter`, { stdio: "ignore" });
-                    dispatch({ type: "SET_ACTION_MESSAGE", message: "Launched review in tmux" });
-                }
-                catch {
-                    dispatch({ type: "SET_ACTION_MESSAGE", message: "Failed to launch review" });
-                }
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: created.ok
+                            ? `Launched review in ${mux.kind}`
+                            : `Failed to launch review${created.message ? `: ${created.message}` : ""}`,
+                    });
+                })();
             }
             else {
                 leaveAltScreen();
@@ -1467,18 +1482,23 @@ export default function Dashboard() {
                 dispatch({ type: "SET_ACTION_MESSAGE", message: "No PR to fix" });
                 return;
             }
-            if (isInTmux()) {
+            const mux = getMultiplexer();
+            if (mux.isActive()) {
                 const windowName = `fix-${di.issue.identifier}`;
-                try {
-                    execSync(`tmux new-window -n "${windowName}" -c "${di.worktree.path}"`, {
-                        stdio: "ignore",
+                const cwd = di.worktree.path;
+                void (async () => {
+                    const created = await mux.createWindow({
+                        name: windowName,
+                        cwd,
+                        command: "st pr fix",
                     });
-                    execSync(`tmux send-keys -t "${windowName}" "st pr fix" Enter`, { stdio: "ignore" });
-                    dispatch({ type: "SET_ACTION_MESSAGE", message: "Launched PR fix in tmux" });
-                }
-                catch {
-                    dispatch({ type: "SET_ACTION_MESSAGE", message: "Failed to launch PR fix" });
-                }
+                    dispatch({
+                        type: "SET_ACTION_MESSAGE",
+                        message: created.ok
+                            ? `Launched PR fix in ${mux.kind}`
+                            : `Failed to launch PR fix${created.message ? `: ${created.message}` : ""}`,
+                    });
+                })();
             }
             else {
                 leaveAltScreen();
@@ -1510,7 +1530,7 @@ export default function Dashboard() {
     }
     const selectedIssue = state.flatIssues[state.selectedIndex] ?? null;
     const selectedReview = state.flatReviews[state.reviewSelectedIndex] ?? null;
-    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: "Santree Dashboard" }), _jsxs(Text, { dimColor: true, children: ["  ", "v", version] }), CLAUDE_VERSION ? (_jsxs(Text, { dimColor: true, children: ["  ", "claude ", CLAUDE_VERSION] })) : null, _jsx(Text, { dimColor: true, children: state.refreshing ? "  refreshing..." : "" }), state.actionMessage && (_jsxs(Text, { color: "yellow", children: ["  ", state.actionMessage] }))] }), _jsxs(Box, { children: [_jsxs(Text, { bold: state.activeTab === "issues", color: state.activeTab === "issues" ? "cyan" : undefined, dimColor: state.activeTab !== "issues", children: [state.activeTab === "issues" ? "\u25b8 " : "  ", "1 Issues (", state.flatIssues.length, ")"] }), _jsx(Text, { children: "   " }), _jsxs(Text, { bold: state.activeTab === "reviews", color: state.activeTab === "reviews" ? "cyan" : undefined, dimColor: state.activeTab !== "reviews", children: [state.activeTab === "reviews" ? "\u25b8 " : "  ", "2 Reviews (", state.flatReviews.length, ")"] })] }), state.overlay === "mode-select" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Select mode:" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "p" }), "  Plan"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "i" }), "  Implement"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }) })) : state.overlay === "context-input" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", paddingX: 2, width: Math.min(columns - 8, 100), children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Extra context for ", state.contextInputMode] }), _jsx(Text, { dimColor: true, children: "Optional \u2014 appended to the prompt before launching Claude" }), _jsx(Text, { children: " " }), state.contextInputPhase === "editing" ? (_jsxs(_Fragment, { children: [_jsx(MultilineTextArea, { value: state.contextInputValue, onChange: (v) => dispatch({ type: "CONTEXT_INPUT_CHANGE", value: v }), onSubmit: () => dispatch({ type: "CONTEXT_INPUT_REVIEW" }), onCancel: () => dispatch({ type: "CONTEXT_INPUT_DONE" }), width: Math.min(columns - 8, 100), height: 10, placeholder: "Type or paste extra context\u2026" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: "cyan", bold: true, children: "Enter" }), " newline  ", _jsx(Text, { color: "cyan", bold: true, children: "\u2191\u2193\u2190\u2192" }), " move  ", _jsx(Text, { color: "cyan", bold: true, children: "Ctrl+V" }), " paste image  ", _jsx(Text, { color: "cyan", bold: true, children: "Ctrl+D" }), " continue  ", _jsx(Text, { color: "cyan", bold: true, children: "ESC" }), " cancel"] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, minHeight: 6, children: [(state.contextInputValue || "(no extra context)")
+    return (_jsxs(Box, { width: columns, height: rows, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: "Santree Dashboard" }), _jsxs(Text, { dimColor: true, children: ["  ", "v", version] }), CLAUDE_VERSION ? (_jsxs(Text, { dimColor: true, children: ["  ", "claude ", CLAUDE_VERSION] })) : null, _jsx(Text, { dimColor: true, children: state.refreshing ? "  refreshing..." : "" }), state.actionMessage && (_jsxs(Text, { color: "yellow", children: ["  ", state.actionMessage] }))] }), _jsxs(Box, { children: [_jsxs(Text, { bold: state.activeTab === "issues", color: state.activeTab === "issues" ? "cyan" : undefined, dimColor: state.activeTab !== "issues", children: [state.activeTab === "issues" ? "\u25b8 " : "  ", "1 Issues (", state.flatIssues.length, ")"] }), _jsx(Text, { children: "   " }), _jsxs(Text, { bold: state.activeTab === "reviews", color: state.activeTab === "reviews" ? "cyan" : undefined, dimColor: state.activeTab !== "reviews", children: [state.activeTab === "reviews" ? "\u25b8 " : "  ", "2 Reviews (", state.flatReviews.length, ")"] })] }), state.overlay === "mode-select" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Select mode:" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "p" }), "  Plan"] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", bold: true, children: "i" }), "  Implement"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "ESC to cancel" })] }) })) : state.overlay === "context-input" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", paddingX: 2, width: Math.min(columns - 8, 100), children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Extra context for ", state.contextInputMode] }), _jsx(Text, { dimColor: true, children: "Optional \u2014 appended to the prompt before launching Claude" }), _jsx(Text, { children: " " }), state.contextInputPhase === "editing" ? (_jsxs(_Fragment, { children: [_jsx(MultilineTextArea, { value: state.contextInputValue, onChange: (v) => dispatch({ type: "CONTEXT_INPUT_CHANGE", value: v }), onSubmit: () => dispatch({ type: "CONTEXT_INPUT_REVIEW" }), onCancel: () => dispatch({ type: "CONTEXT_INPUT_DONE" }), width: Math.min(columns - 8, 100), height: 10, placeholder: "Type or paste extra context\u2026" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: "cyan", bold: true, children: "Ctrl+D" }), " send  ·  ", _jsx(Text, { color: "cyan", bold: true, children: "Ctrl+O" }), " editor  ·  ", _jsx(Text, { color: "cyan", bold: true, children: "Ctrl+C" }), " cancel"] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, minHeight: 6, children: [(state.contextInputValue || "(no extra context)")
                                             .split("\n")
                                             .slice(0, 12)
                                             .map((line, i) => (_jsx(Text, { children: line || " " }, i))), state.contextInputValue.split("\n").length > 12 && (_jsxs(Text, { dimColor: true, children: ["\u2026+", state.contextInputValue.split("\n").length - 12, " more lines"] }))] }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Anything else to add?" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "green", bold: true, children: "y" }), " / ", _jsx(Text, { color: "green", bold: true, children: "Enter" }), "  launch   ", _jsx(Text, { color: "yellow", bold: true, children: "n" }), " / ", _jsx(Text, { color: "yellow", bold: true, children: "e" }), "  keep editing   ", _jsx(Text, { color: "red", bold: true, children: "ESC" }), "  cancel"] })] }))] }) })) : state.overlay === "base-select" ? (_jsx(Box, { flexGrow: 1, justifyContent: "center", alignItems: "center", children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 3, paddingY: 1, children: [_jsx(Text, { bold: true, children: "Select base branch:" }), _jsx(Text, { children: " " }), state.baseSelectOptions.map((branch, idx) => {

package/dist/commands/doctor.js

@@ -11,6 +11,7 @@ const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 import { findMainRepoRoot, getSantreeDir, getInitScriptPath } from "../lib/git.js";
 import { getAuthStatus, getValidTokens } from "../lib/linear.js";
+import { getMultiplexer } from "../lib/multiplexer/index.js";
 const execAsync = promisify(exec);
 export const description = "Check system requirements and integrations";
 /**
@@ -55,6 +56,70 @@ async function checkTool(name, description, required, versionCommand, hint) {
         path,
     };
 }
+/**
+ * Reports the active multiplexer (tmux/cmux/none) and verifies the underlying
+ * binary is reachable. Surfaces a hint when the configured multiplexer can't run.
+ */
+async function checkMultiplexer() {
+    const mux = getMultiplexer();
+    const explicit = process.env["SANTREE_MULTIPLEXER"]?.toLowerCase();
+    const description = `Multiplexer (active: ${mux.kind}${explicit ? `, SANTREE_MULTIPLEXER=${explicit}` : ""})`;
+    if (mux.kind === "none") {
+        return {
+            name: "multiplexer",
+            description,
+            required: false,
+            installed: false,
+            hint: "No multiplexer active. Set SANTREE_MULTIPLEXER=tmux (or cmux) and run inside one. Install: brew install tmux",
+        };
+    }
+    if (mux.kind === "tmux") {
+        const path = await getPath("tmux");
+        if (!path) {
+            return {
+                name: "tmux",
+                description,
+                required: false,
+                installed: false,
+                hint: "Install: brew install tmux",
+            };
+        }
+        const version = await tryExec("tmux -V");
+        return {
+            name: "tmux",
+            description,
+            required: false,
+            installed: true,
+            version: version || "unknown",
+            path,
+        };
+    }
+    // cmux
+    const path = await getPath("cmux");
+    if (!path) {
+        return {
+            name: "cmux",
+            description,
+            required: false,
+            installed: false,
+            hint: "Install cmux.app from https://cmux.com or set SANTREE_MULTIPLEXER=tmux. cmux is macOS-only.",
+        };
+    }
+    const version = await tryExec("cmux --version 2>/dev/null");
+    const ping = await tryExec("cmux ping 2>/dev/null");
+    const hint = !ping
+        ? "cmux app not reachable — open cmux.app or set SANTREE_MULTIPLEXER=tmux. NOTE: cmux #1472 — programmatic workspaces may have dead PTYs (https://github.com/manaflow-ai/cmux/issues/1472)."
+        : "NOTE: cmux #1472 — programmatic workspaces may have dead PTYs (https://github.com/manaflow-ai/cmux/issues/1472).";
+    return {
+        name: "cmux",
+        description,
+        required: false,
+        installed: !!ping,
+        version: version || "unknown",
+        path,
+        hint,
+    };
+}
 /**
  * Checks GitHub CLI auth status.
  * Uses `gh api user` which works across all gh versions.
@@ -399,7 +464,7 @@ export default function Doctor() {
             const results = await Promise.all([
                 checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
                 checkGhAuth(),
-                checkTool("tmux", "Terminal multiplexer", false, "tmux -V", "Install: brew install tmux"),
+                checkMultiplexer(),
                 checkTool("claude", "Claude Code CLI", true, "claude --version 2>/dev/null | head -1", "Install: npm install -g @anthropic-ai/claude-code"),
             ]);
             // Check for either code or cursor (only need one)

package/dist/commands/helpers/text-editor.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+export declare const description = "Open $EDITOR on a temp file, then print the path on stdout (compose with --context-file).";
+export declare const options: z.ZodObject<{
+    initial: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    ext: z.ZodDefault<z.ZodString>;
+    editor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function TextEditor({ options: opts }: Props): null;
+export {};

package/dist/commands/helpers/text-editor.js

@@ -0,0 +1,118 @@
+import { useEffect, useRef } from "react";
+import { useApp } from "ink";
+import { option } from "pastel";
+import { z } from "zod/v4";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const description = "Open $EDITOR on a temp file, then print the path on stdout (compose with --context-file).";
+export const options = z.object({
+    initial: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with this text" })),
+    from: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with the contents of this file" })),
+    ext: z
+        .string()
+        .default("md")
+        .describe(option({ description: "Temp file extension (default: md)" })),
+    editor: z
+        .string()
+        .optional()
+        .describe(option({ description: "Override the editor command (default: $VISUAL || $EDITOR || vim)" })),
+});
+function resolveEditor(override) {
+    const raw = override ?? process.env["VISUAL"] ?? process.env["EDITOR"] ?? "vim";
+    const parts = raw.split(/\s+/).filter(Boolean);
+    const cmd = parts[0] ?? "vim";
+    return { cmd, args: parts.slice(1) };
+}
+// Render null and write all UI feedback to stderr so stdout stays clean for
+// shell capture: `file=$(st helpers text-editor) && st worktree work --context-file "$file"`.
+export default function TextEditor({ options: opts }) {
+    const { exit } = useApp();
+    const hasRun = useRef(false);
+    useEffect(() => {
+        if (hasRun.current)
+            return;
+        hasRun.current = true;
+        const ext = opts.ext.replace(/^\./, "");
+        const filePath = path.join(os.tmpdir(), `santree-edit-${Date.now()}.${ext}`);
+        const seed = (() => {
+            if (opts.from) {
+                try {
+                    return fs.readFileSync(opts.from, "utf-8");
+                }
+                catch {
+                    return opts.initial ?? "";
+                }
+            }
+            return opts.initial ?? "";
+        })();
+        try {
+            fs.writeFileSync(filePath, seed);
+        }
+        catch (err) {
+            process.stderr.write(`Failed to create temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Ink put stdin in raw mode on mount; release it for the editor.
+        const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+        }
+        const { cmd, args } = resolveEditor(opts.editor);
+        const result = spawnSync(cmd, [...args, filePath], { stdio: "inherit" });
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(wasRaw);
+            }
+            catch { }
+        }
+        if (result.error || result.status !== 0) {
+            process.stderr.write(result.error
+                ? `Failed to launch editor '${cmd}': ${result.error.message}\n`
+                : `Editor '${cmd}' exited with status ${result.status}\n`);
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        let content = "";
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch (err) {
+            process.stderr.write(`Failed to read temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Empty buffer => treat as cancel (matches `git commit` behavior)
+        if (content.trim().length === 0) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.stderr.write("Cancelled (empty buffer)\n");
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        process.stdout.write(`${filePath}\n`);
+        exit();
+    }, [opts, exit]);
+    return null;
+}

package/dist/commands/worktree/create.d.ts

@@ -5,6 +5,7 @@ export declare const options: z.ZodObject<{
     work: z.ZodOptional<z.ZodBoolean>;
     plan: z.ZodOptional<z.ZodBoolean>;
     "no-pull": z.ZodOptional<z.ZodBoolean>;
+    window: z.ZodOptional<z.ZodBoolean>;
     tmux: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;